Termination w.r.t. Q proof of /home/nowonder/forschung/aprove/satrung/aprove/lpar14/AProVESLASHLiveness6.3.trs

Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

TOP₁(rec₁(up₁(x))) -> REC₁(x)
CHECK₁(no₁(x)) -> CHECK₁(x)
REC₁(bot) -> SENT₁(bot)
REC₁(rec₁(x)) -> SENT₁(rec₁(x))
TOP₁(sent₁(up₁(x))) -> CHECK₁(rec₁(x))
CHECK₁(rec₁(x)) -> CHECK₁(x)
REC₁(up₁(x)) -> REC₁(x)
TOP₁(no₁(up₁(x))) -> REC₁(x)
TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
REC₁(no₁(x)) -> SENT₁(rec₁(x))
CHECK₁(sent₁(x)) -> SENT₁(check₁(x))
CHECK₁(rec₁(x)) -> REC₁(check₁(x))
TOP₁(no₁(up₁(x))) -> CHECK₁(rec₁(x))
CHECK₁(no₁(x)) -> NO₁(check₁(x))
REC₁(sent₁(x)) -> SENT₁(rec₁(x))
CHECK₁(up₁(x)) -> CHECK₁(x)
TOP₁(sent₁(up₁(x))) -> REC₁(x)
TOP₁(rec₁(up₁(x))) -> CHECK₁(rec₁(x))
TOP₁(no₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
REC₁(no₁(x)) -> REC₁(x)
NO₁(up₁(x)) -> NO₁(x)
SENT₁(up₁(x)) -> SENT₁(x)
TOP₁(rec₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
REC₁(sent₁(x)) -> REC₁(x)
CHECK₁(sent₁(x)) -> CHECK₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

TOP₁(rec₁(up₁(x))) -> REC₁(x)
CHECK₁(no₁(x)) -> CHECK₁(x)
REC₁(bot) -> SENT₁(bot)
REC₁(rec₁(x)) -> SENT₁(rec₁(x))
TOP₁(sent₁(up₁(x))) -> CHECK₁(rec₁(x))
CHECK₁(rec₁(x)) -> CHECK₁(x)
REC₁(up₁(x)) -> REC₁(x)
TOP₁(no₁(up₁(x))) -> REC₁(x)
TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
REC₁(no₁(x)) -> SENT₁(rec₁(x))
CHECK₁(sent₁(x)) -> SENT₁(check₁(x))
CHECK₁(rec₁(x)) -> REC₁(check₁(x))
TOP₁(no₁(up₁(x))) -> CHECK₁(rec₁(x))
CHECK₁(no₁(x)) -> NO₁(check₁(x))
REC₁(sent₁(x)) -> SENT₁(rec₁(x))
CHECK₁(up₁(x)) -> CHECK₁(x)
TOP₁(sent₁(up₁(x))) -> REC₁(x)
TOP₁(rec₁(up₁(x))) -> CHECK₁(rec₁(x))
TOP₁(no₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
REC₁(no₁(x)) -> REC₁(x)
NO₁(up₁(x)) -> NO₁(x)
SENT₁(up₁(x)) -> SENT₁(x)
TOP₁(rec₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
REC₁(sent₁(x)) -> REC₁(x)
CHECK₁(sent₁(x)) -> CHECK₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 5 SCCs with 13 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

NO₁(up₁(x)) -> NO₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

NO₁(up₁(x)) -> NO₁(x)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
NO₁(x1) = NO₁(x1)
up₁(x1) = up₁(x1)

Lexicographic Path Order [19].
Precedence:

up₁ > NO₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SENT₁(up₁(x)) -> SENT₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

SENT₁(up₁(x)) -> SENT₁(x)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
SENT₁(x1) = SENT₁(x1)
up₁(x1) = up₁(x1)

Lexicographic Path Order [19].
Precedence:

up₁ > SENT₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

REC₁(up₁(x)) -> REC₁(x)
REC₁(no₁(x)) -> REC₁(x)
REC₁(sent₁(x)) -> REC₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

REC₁(no₁(x)) -> REC₁(x)

The remaining pairs can at least by weakly be oriented.

REC₁(up₁(x)) -> REC₁(x)
REC₁(sent₁(x)) -> REC₁(x)

Used ordering: Combined order from the following AFS and order.
REC₁(x1) = REC₁(x1)
up₁(x1) = x1
no₁(x1) = no₁(x1)
sent₁(x1) = x1

Lexicographic Path Order [19].
Precedence:

[REC₁, no_1]

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

REC₁(up₁(x)) -> REC₁(x)
REC₁(sent₁(x)) -> REC₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

REC₁(sent₁(x)) -> REC₁(x)

The remaining pairs can at least by weakly be oriented.

REC₁(up₁(x)) -> REC₁(x)

Used ordering: Combined order from the following AFS and order.
REC₁(x1) = REC₁(x1)
up₁(x1) = x1
sent₁(x1) = sent₁(x1)

Lexicographic Path Order [19].
Precedence:

trivial

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

REC₁(up₁(x)) -> REC₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

REC₁(up₁(x)) -> REC₁(x)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
REC₁(x1) = REC₁(x1)
up₁(x1) = up₁(x1)

Lexicographic Path Order [19].
Precedence:

up₁ > REC₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CHECK₁(no₁(x)) -> CHECK₁(x)
CHECK₁(up₁(x)) -> CHECK₁(x)
CHECK₁(sent₁(x)) -> CHECK₁(x)
CHECK₁(rec₁(x)) -> CHECK₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

CHECK₁(up₁(x)) -> CHECK₁(x)

The remaining pairs can at least by weakly be oriented.

CHECK₁(no₁(x)) -> CHECK₁(x)
CHECK₁(sent₁(x)) -> CHECK₁(x)
CHECK₁(rec₁(x)) -> CHECK₁(x)

Used ordering: Combined order from the following AFS and order.
CHECK₁(x1) = CHECK₁(x1)
no₁(x1) = x1
up₁(x1) = up₁(x1)
sent₁(x1) = x1
rec₁(x1) = x1

Lexicographic Path Order [19].
Precedence:

trivial

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CHECK₁(no₁(x)) -> CHECK₁(x)
CHECK₁(sent₁(x)) -> CHECK₁(x)
CHECK₁(rec₁(x)) -> CHECK₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

CHECK₁(sent₁(x)) -> CHECK₁(x)

The remaining pairs can at least by weakly be oriented.

CHECK₁(no₁(x)) -> CHECK₁(x)
CHECK₁(rec₁(x)) -> CHECK₁(x)

Used ordering: Combined order from the following AFS and order.
CHECK₁(x1) = CHECK₁(x1)
no₁(x1) = x1
sent₁(x1) = sent₁(x1)
rec₁(x1) = x1

Lexicographic Path Order [19].
Precedence:

[CHECK₁, sent_1]

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CHECK₁(no₁(x)) -> CHECK₁(x)
CHECK₁(rec₁(x)) -> CHECK₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

CHECK₁(rec₁(x)) -> CHECK₁(x)

The remaining pairs can at least by weakly be oriented.

CHECK₁(no₁(x)) -> CHECK₁(x)

Used ordering: Combined order from the following AFS and order.
CHECK₁(x1) = CHECK₁(x1)
no₁(x1) = x1
rec₁(x1) = rec₁(x1)

Lexicographic Path Order [19].
Precedence:

trivial

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CHECK₁(no₁(x)) -> CHECK₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

CHECK₁(no₁(x)) -> CHECK₁(x)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
CHECK₁(x1) = CHECK₁(x1)
no₁(x1) = no₁(x1)

Lexicographic Path Order [19].
Precedence:

no₁ > CHECK₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ PisEmptyProof

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

TOP₁(no₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
TOP₁(rec₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

TOP₁(rec₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

The remaining pairs can at least by weakly be oriented.

TOP₁(no₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

Used ordering: Combined order from the following AFS and order.
TOP₁(x1) = TOP₁(x1)
no₁(x1) = x1
up₁(x1) = up₁(x1)
check₁(x1) = x1
rec₁(x1) = rec₁(x1)
sent₁(x1) = x1
bot = bot

Lexicographic Path Order [19].
Precedence:

TOP₁ > [up₁, rec_1] > bot

The following usable rules [14] were oriented:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)
no₁(up₁(x)) -> up₁(no₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

TOP₁(no₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

TOP₁(no₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

The remaining pairs can at least by weakly be oriented.

TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

Used ordering: Combined order from the following AFS and order.
TOP₁(x1) = x1
no₁(x1) = no₁(x1)
up₁(x1) = up₁(x1)
check₁(x1) = x1
rec₁(x1) = rec₁(x1)
sent₁(x1) = x1
bot = bot

Lexicographic Path Order [19].
Precedence:

no₁ > [up₁, rec_1]
bot > [up₁, rec_1]

The following usable rules [14] were oriented:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)
no₁(up₁(x)) -> up₁(no₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.